home *** CD-ROM | disk | FTP | other *** search
/ TeX 1995 July / TeX CD-ROM July 1995 (Disc 1)(Walnut Creek)(1995).ISO / biblio / bibtex / mac / macbibtex11.hqx / 0.99c Sources / MacBibTeX 0.99c v1.1.sit / MacBibTex 0.99c V1.1 / bibtex_2.c < prev    next >
C/C++ Source or Header  |  1988-09-02  |  27KB  |  1,127 lines
  1. #include "bibtex.h"
  2.  
  3. #include "bibtex.p"
  4. #include "globals.h"
  5. #include "coerce.h"
  6.  
  7. zbuildin ( pds , len , fnhashloc , bltinnum ) 
  8. pdstype pds ; 
  9. pdslen len ; 
  10. hashloc * fnhashloc ; 
  11. bltinrange bltinnum ; 
  12. {predefine ( pds , len , 11 ) ; 
  13. *  fnhashloc = predefloc ; 
  14.   fntype [ *fnhashloc ] = 0 ; 
  15.   ilkinfo [ *fnhashloc ] = bltinnum ; 
  16.     ;
  17. #ifdef STAT
  18.   bltinloc [ bltinnum ] = *fnhashloc ; 
  19.   executioncount [ bltinnum ] = 0 ; 
  20. #endif /* STAT */
  21. } 
  22. predefcertainstrings () {
  23.     predefine ( ".aux        " , 4 , 7 ) ;
  24.   sauxextension = hashtext [ predefloc ] ; 
  25.   predefine ( ".bbl        " , 4 , 7 ) ; 
  26.   sbblextension = hashtext [ predefloc ] ; 
  27.   predefine ( ".blg        " , 4 , 7 ) ; 
  28.   slogextension = hashtext [ predefloc ] ; 
  29.   predefine ( ".bst        " , 4 , 7 ) ; 
  30.   sbstextension = hashtext [ predefloc ] ; 
  31.   predefine ( ".bib        " , 4 , 7 ) ; 
  32.   sbibextension = hashtext [ predefloc ] ; 
  33.   predefine ( "texinputs:  " , 10 , 8 ) ; 
  34.   sbstarea = hashtext [ predefloc ] ; 
  35.   predefine ( "texbib:     " , 7 , 8 ) ; 
  36.   sbibarea = hashtext [ predefloc ] ; 
  37.   predefine ( "\\citation   " , 9 , 2 ) ; 
  38.   ilkinfo [ predefloc ] = 2 ; 
  39.   predefine ( "\\bibdata    " , 8 , 2 ) ; 
  40.   ilkinfo [ predefloc ] = 0 ; 
  41.   predefine ( "\\bibstyle   " , 9 , 2 ) ; 
  42.   ilkinfo [ predefloc ] = 1 ; 
  43.   predefine ( "\\@input     " , 7 , 2 ) ; 
  44.   ilkinfo [ predefloc ] = 3 ; 
  45.   predefine ( "entry       " , 5 , 4 ) ; 
  46.   ilkinfo [ predefloc ] = 0 ; 
  47.   predefine ( "execute     " , 7 , 4 ) ; 
  48.   ilkinfo [ predefloc ] = 1 ; 
  49.   predefine ( "function    " , 8 , 4 ) ; 
  50.   ilkinfo [ predefloc ] = 2 ; 
  51.   predefine ( "integers    " , 8 , 4 ) ; 
  52.   ilkinfo [ predefloc ] = 3 ; 
  53.   predefine ( "iterate     " , 7 , 4 ) ; 
  54.   ilkinfo [ predefloc ] = 4 ; 
  55.   predefine ( "macro       " , 5 , 4 ) ; 
  56.   ilkinfo [ predefloc ] = 5 ; 
  57.   predefine ( "read        " , 4 , 4 ) ; 
  58.   ilkinfo [ predefloc ] = 6 ; 
  59.   predefine ( "reverse     " , 7 , 4 ) ; 
  60.   ilkinfo [ predefloc ] = 7 ; 
  61.   predefine ( "sort        " , 4 , 4 ) ; 
  62.   ilkinfo [ predefloc ] = 8 ; 
  63.   predefine ( "strings     " , 7 , 4 ) ; 
  64.   ilkinfo [ predefloc ] = 9 ; 
  65.   predefine ( "comment     " , 7 , 12 ) ; 
  66.   ilkinfo [ predefloc ] = 0 ; 
  67.   predefine ( "preamble    " , 8 , 12 ) ; 
  68.   ilkinfo [ predefloc ] = 1 ; 
  69.   predefine ( "string      " , 6 , 12 ) ; 
  70.   ilkinfo [ predefloc ] = 2 ; 
  71.   buildin ( "=           " , 1 , bequals , 0 ) ; 
  72.   buildin ( ">           " , 1 , bgreaterthan , 1 ) ; 
  73.   buildin ( "<           " , 1 , blessthan , 2 ) ; 
  74.   buildin ( "+           " , 1 , bplus , 3 ) ; 
  75.   buildin ( "-           " , 1 , bminus , 4 ) ; 
  76.   buildin ( "*           " , 1 , bconcatenate , 5 ) ; 
  77.   buildin ( ":=          " , 2 , bgets , 6 ) ; 
  78.   buildin ( "add.period$ " , 11 , baddperiod , 7 ) ; 
  79.   buildin ( "call.type$  " , 10 , bcalltype , 8 ) ; 
  80.   buildin ( "change.case$" , 12 , bchangecase , 9 ) ; 
  81.   buildin ( "chr.to.int$ " , 11 , bchrtoint , 10 ) ; 
  82.   buildin ( "cite$       " , 5 , bcite , 11 ) ; 
  83.   buildin ( "duplicate$  " , 10 , bduplicate , 12 ) ; 
  84.   buildin ( "empty$      " , 6 , bempty , 13 ) ; 
  85.   buildin ( "format.name$" , 12 , bformatname , 14 ) ; 
  86.   buildin ( "if$         " , 3 , bif , 15 ) ; 
  87.   buildin ( "int.to.chr$ " , 11 , binttochr , 16 ) ; 
  88.   buildin ( "int.to.str$ " , 11 , binttostr , 17 ) ; 
  89.   buildin ( "missing$    " , 8 , bmissing , 18 ) ; 
  90.   buildin ( "newline$    " , 8 , bnewline , 19 ) ; 
  91.   buildin ( "num.names$  " , 10 , bnumnames , 20 ) ; 
  92.   buildin ( "pop$        " , 4 , bpop , 21 ) ; 
  93.   buildin ( "preamble$   " , 9 , bpreamble , 22 ) ; 
  94.   buildin ( "purify$     " , 7 , bpurify , 23 ) ; 
  95.   buildin ( "quote$      " , 6 , bquote , 24 ) ; 
  96.   buildin ( "skip$       " , 5 , bskip , 25 ) ; 
  97.   buildin ( "stack$      " , 6 , bstack , 26 ) ; 
  98.   buildin ( "substring$  " , 10 , bsubstring , 27 ) ; 
  99.   buildin ( "swap$       " , 5 , bswap , 28 ) ; 
  100.   buildin ( "text.length$" , 12 , btextlength , 29 ) ; 
  101.   buildin ( "text.prefix$" , 12 , btextprefix , 30 ) ; 
  102.   buildin ( "top$        " , 4 , btopstack , 31 ) ; 
  103.   buildin ( "type$       " , 5 , btype , 32 ) ; 
  104.   buildin ( "warning$    " , 8 , bwarning , 33 ) ; 
  105.   buildin ( "width$      " , 6 , bwidth , 35 ) ; 
  106.   buildin ( "while$      " , 6 , bwhile , 34 ) ; 
  107.   buildin ( "width$      " , 6 , bwidth , 35 ) ; 
  108.   buildin ( "write$      " , 6 , bwrite , 36 ) ; 
  109.   predefine ( "            " , 0 , 0 ) ; 
  110.   snull = hashtext [ predefloc ] ; 
  111.   fntype [ predefloc ] = 3 ; 
  112.   predefine ( "default.type" , 12 , 0 ) ; 
  113.   sdefault = hashtext [ predefloc ] ; 
  114.   fntype [ predefloc ] = 3 ; 
  115.   bdefault = bskip ; 
  116.   preambleptr = 0 ; 
  117.   predefine ( "i           " , 1 , 14 ) ; 
  118.   ilkinfo [ predefloc ] = 0 ; 
  119.   predefine ( "j           " , 1 , 14 ) ; 
  120.   ilkinfo [ predefloc ] = 1 ; 
  121.   predefine ( "oe          " , 2 , 14 ) ; 
  122.   ilkinfo [ predefloc ] = 2 ; 
  123.   predefine ( "OE          " , 2 , 14 ) ; 
  124.   ilkinfo [ predefloc ] = 3 ; 
  125.   predefine ( "ae          " , 2 , 14 ) ; 
  126.   ilkinfo [ predefloc ] = 4 ; 
  127.   predefine ( "AE          " , 2 , 14 ) ; 
  128.   ilkinfo [ predefloc ] = 5 ; 
  129.   predefine ( "aa          " , 2 , 14 ) ; 
  130.   ilkinfo [ predefloc ] = 6 ; 
  131.   predefine ( "AA          " , 2 , 14 ) ; 
  132.   ilkinfo [ predefloc ] = 7 ; 
  133.   predefine ( "o           " , 1 , 14 ) ; 
  134.   ilkinfo [ predefloc ] = 8 ; 
  135.   predefine ( "O           " , 1 , 14 ) ; 
  136.   ilkinfo [ predefloc ] = 9 ; 
  137.   predefine ( "l           " , 1 , 14 ) ; 
  138.   ilkinfo [ predefloc ] = 10 ; 
  139.   predefine ( "L           " , 1 , 14 ) ; 
  140.   ilkinfo [ predefloc ] = 11 ; 
  141.   predefine ( "ss          " , 2 , 14 ) ; 
  142.   ilkinfo [ predefloc ] = 12 ; 
  143.   predefine ( "crossref    " , 8 , 11 ) ; 
  144.   fntype [ predefloc ] = 4 ; 
  145.   ilkinfo [ predefloc ] = numfields ; 
  146.   crossrefnum = numfields ; 
  147.   incr ( numfields ) ; 
  148.   numpredefinedfields = numfields ; 
  149.   predefine ( "sort.key$   " , 9 , 11 ) ; 
  150.   fntype [ predefloc ] = 6 ; 
  151.   ilkinfo [ predefloc ] = numentstrs ; 
  152.   sortkeynum = numentstrs ; 
  153.   incr ( numentstrs ) ; 
  154.   predefine ( "entry.max$  " , 10 , 11 ) ; 
  155.   fntype [ predefloc ] = 7 ; 
  156.   ilkinfo [ predefloc ] = entstrsize ; 
  157.   predefine ( "global.max$ " , 11 , 11 ) ; 
  158.   fntype [ predefloc ] = 7 ; 
  159.   ilkinfo [ predefloc ] = globstrsize ; 
  160. } 
  161. boolean zscan1 ( char1 ) 
  162. ASCIIcode char1 ; 
  163. {register boolean Result; bufptr1 = bufptr2 ; 
  164.   while ( ( ( buffer [ bufptr2 ] != char1 ) && ( bufptr2 < last ) ) ) incr ( 
  165.   bufptr2 ) ; 
  166.   if ( ( bufptr2 < last ) ) 
  167.   Result = true ; 
  168.   else Result = false ; 
  169.   return(Result) ; 
  170. } 
  171. boolean zscan1white ( char1 ) 
  172. ASCIIcode char1 ; 
  173. {register boolean Result; bufptr1 = bufptr2 ; 
  174.   while ( ( ( lexclass [ buffer [ bufptr2 ] ] != 1 ) && ( buffer [ bufptr2 ] 
  175.   != char1 ) && ( bufptr2 < last ) ) ) incr ( bufptr2 ) ; 
  176.   if ( ( bufptr2 < last ) ) 
  177.   Result = true ; 
  178.   else Result = false ; 
  179.   return(Result) ; 
  180. } 
  181. boolean zscan2 ( char1 , char2 ) 
  182. ASCIIcode char1 , char2 ; 
  183. {register boolean Result; bufptr1 = bufptr2 ; 
  184.   while ( ( ( buffer [ bufptr2 ] != char1 ) && ( buffer [ bufptr2 ] != char2 ) 
  185.   && ( bufptr2 < last ) ) ) incr ( bufptr2 ) ; 
  186.   if ( ( bufptr2 < last ) ) 
  187.   Result = true ; 
  188.   else Result = false ; 
  189.   return(Result) ; 
  190. } 
  191. boolean zscan2white ( char1 , char2 ) 
  192. ASCIIcode char1 , char2 ; 
  193. {register boolean Result; bufptr1 = bufptr2 ; 
  194.   while ( ( ( buffer [ bufptr2 ] != char1 ) && ( buffer [ bufptr2 ] != char2 ) 
  195.   && ( lexclass [ buffer [ bufptr2 ] ] != 1 ) && ( bufptr2 < last ) ) ) incr ( 
  196.   bufptr2 ) ; 
  197.   if ( ( bufptr2 < last ) ) 
  198.   Result = true ; 
  199.   else Result = false ; 
  200.   return(Result) ; 
  201. } 
  202. boolean zscan3 ( char1 , char2 , char3 ) 
  203. ASCIIcode char1 , char2 , char3 ; 
  204. {register boolean Result; bufptr1 = bufptr2 ; 
  205.   while ( ( ( buffer [ bufptr2 ] != char1 ) && ( buffer [ bufptr2 ] != char2 ) 
  206.   && ( buffer [ bufptr2 ] != char3 ) && ( bufptr2 < last ) ) ) incr ( bufptr2 
  207.   ) ; 
  208.   if ( ( bufptr2 < last ) ) 
  209.   Result = true ; 
  210.   else Result = false ; 
  211.   return(Result) ; 
  212. } 
  213. boolean scanalpha () {
  214.     register boolean Result; bufptr1 = bufptr2 ; 
  215.   while ( ( ( lexclass [ buffer [ bufptr2 ] ] == 2 ) && ( bufptr2 < last ) ) ) 
  216.   incr ( bufptr2 ) ; 
  217.   if ( ( ( bufptr2 - bufptr1 ) == 0 ) ) 
  218.   Result = false ; 
  219.   else Result = true ; 
  220.   return(Result) ; 
  221. } 
  222. zscanidentifier ( char1 , char2 , char3 ) 
  223. ASCIIcode char1 , char2 , char3 ; 
  224. {bufptr1 = bufptr2 ; 
  225.   if ( ( lexclass [ buffer [ bufptr2 ] ] != 3 ) ) 
  226.   while ( ( ( idclass [ buffer [ bufptr2 ] ] == 1 ) && ( bufptr2 < last ) ) ) 
  227.   incr ( bufptr2 ) ; 
  228.   if ( ( ( bufptr2 - bufptr1 ) == 0 ) ) 
  229.   scanresult = 0 ; 
  230.   else if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 == last ) 
  231.   ) ) 
  232.   scanresult = 3 ; 
  233.   else if ( ( ( buffer [ bufptr2 ] == char1 ) || ( buffer [ bufptr2 ] == char2 
  234.   ) || ( buffer [ bufptr2 ] == char3 ) ) ) 
  235.   scanresult = 1 ; 
  236.   else scanresult = 2 ; 
  237. } 
  238. boolean scannonneginteger () {
  239.     register boolean Result; bufptr1 = bufptr2 ; 
  240.   tokenvalue = 0 ; 
  241.   while ( ( ( lexclass [ buffer [ bufptr2 ] ] == 3 ) && ( bufptr2 < last ) ) ) 
  242.   {
  243.     tokenvalue = tokenvalue * 10 + ( buffer [ bufptr2 ] - 48 ) ; 
  244.     incr ( bufptr2 ) ; 
  245.   } 
  246.   if ( ( ( bufptr2 - bufptr1 ) == 0 ) ) 
  247.   Result = false ; 
  248.   else Result = true ; 
  249.   return(Result) ; 
  250. } 
  251. boolean scaninteger () {
  252.     register boolean Result; schar signlength  ; 
  253.   bufptr1 = bufptr2 ; 
  254.   if ( ( buffer [ bufptr2 ] == 45 ) ) 
  255.   {
  256.     signlength = 1 ; 
  257.     incr ( bufptr2 ) ; 
  258.   } 
  259.   else signlength = 0 ; 
  260.   tokenvalue = 0 ; 
  261.   while ( ( ( lexclass [ buffer [ bufptr2 ] ] == 3 ) && ( bufptr2 < last ) ) ) 
  262.   {
  263.     tokenvalue = tokenvalue * 10 + ( buffer [ bufptr2 ] - 48 ) ; 
  264.     incr ( bufptr2 ) ; 
  265.   } 
  266.   if ( ( ( signlength == 1 ) ) ) 
  267.   tokenvalue = - (integer) tokenvalue ; 
  268.   if ( ( ( bufptr2 - bufptr1 ) == signlength ) ) 
  269.   Result = false ; 
  270.   else Result = true ; 
  271.   return(Result) ; 
  272. } 
  273. boolean scanwhitespace () {
  274.     register boolean Result; while ( ( ( lexclass [ 
  275.   buffer [ bufptr2 ] ] == 1 ) && ( bufptr2 < last ) ) ) incr ( bufptr2 ) ; 
  276.   if ( ( bufptr2 < last ) ) 
  277.   Result = true ; 
  278.   else Result = false ; 
  279.   return(Result) ; 
  280. } 
  281. boolean eatbstwhitespace () {
  282.     /* 10 */ register boolean Result; while ( true ) 
  283.   {
  284.     if ( ( scanwhitespace () ) ) 
  285.     if ( ( buffer [ bufptr2 ] != 37 ) ) 
  286.     {
  287.       Result = true ; 
  288.       goto lab10 ; 
  289.     } 
  290.     if ( ( ! inputln ( bstfile ) ) ) 
  291.     {
  292.       Result = false ; 
  293.       goto lab10 ; 
  294.     } 
  295.     incr ( bstlinenum ) ; 
  296.     bufptr2 = 0 ; 
  297.   } 
  298.   lab10: ; 
  299.   return(Result) ; 
  300. } 
  301. skiptokenprint () {
  302.     { 
  303.     (void) putc( '-' ,  logfile );
  304.     (void) putc( '-' ,  stdout );
  305.   } 
  306.   bstlnnumprint () ; 
  307.   markerror () ; 
  308.   if ( ( scan2white ( 125 , 37 ) ) ) 
  309.   ; 
  310. } 
  311. printrecursionillega () {
  312.     
  313.     ;
  314. #ifdef TRACE
  315.   {
  316.     (void) putc('\n',  logfile );
  317.   } 
  318. #endif /* TRACE */
  319.   {
  320.     (void) fprintf( logfile , "%s\n",  "Curse you, wizard, before you recurse me:" ) ; 
  321.     (void) fprintf( stdout , "%s\n",  "Curse you, wizard, before you recurse me:" ) ; 
  322.   } 
  323.   {
  324.     (void) Fputs( logfile ,  "function " ) ; 
  325.     (void) Fputs( stdout ,  "function " ) ; 
  326.   } 
  327.   printatoken () ; 
  328.   {
  329.     (void) fprintf( logfile , "%s\n",  " is illegal in its own definition" ) ; 
  330.     (void) fprintf( stdout , "%s\n",  " is illegal in its own definition" ) ; 
  331.   } 
  332.   skiptokenprint () ; 
  333. } 
  334. skptokenunknownfunct () {
  335.     printatoken () ; 
  336.   {
  337.     (void) Fputs( logfile ,  " is an unknown function" ) ; 
  338.     (void) Fputs( stdout ,  " is an unknown function" ) ; 
  339.   } 
  340.   skiptokenprint () ; 
  341. } 
  342. skipillegalstuffafte () {
  343.     { 
  344.     (void) fprintf( logfile , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" can't follow a literal" ) ; 
  345.     (void) fprintf( stdout , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" can't follow a literal" ) ; 
  346.   } 
  347.   skiptokenprint () ; 
  348. } 
  349. zscanfndef ( fnhashloc ) 
  350. hashloc fnhashloc ; 
  351. {/* 25 10 */ typedef integer fndefloc  ; 
  352.   hashptr2 singlfunction[singlefnspace + 1]  ; 
  353.   fndefloc singleptr  ; 
  354.   fndefloc copyptr  ; 
  355.   bufpointer endofnum  ; 
  356.   hashloc implfnloc  ; 
  357.   {
  358.     if ( ( ! eatbstwhitespace () ) ) 
  359.     {
  360.       eatbstprint () ; 
  361.       {
  362.     {
  363.       (void) Fputs( logfile ,  "function" ) ; 
  364.       (void) Fputs( stdout ,  "function" ) ; 
  365.     } 
  366.     {
  367.       bsterrprintandlookfo () ; 
  368.       goto lab10 ; 
  369.     } 
  370.       } 
  371.     } 
  372.   } 
  373.   singleptr = 0 ; 
  374.   while ( ( buffer [ bufptr2 ] != 125 ) ) {
  375.       
  376.     switch ( ( buffer [ bufptr2 ] ) ) 
  377.     {case 35 : 
  378.       {
  379.     incr ( bufptr2 ) ; 
  380.     if ( ( ! scaninteger () ) ) 
  381.     {
  382.       {
  383.         (void) Fputs( logfile ,  "Illegal integer in integer literal" ) ; 
  384.         (void) Fputs( stdout ,  "Illegal integer in integer literal" ) ; 
  385.       } 
  386.       skiptokenprint () ; 
  387.       goto lab25 ; 
  388.     } 
  389.     ;
  390. #ifdef TRACE
  391.     {
  392.       (void) putc( '#' ,  logfile );
  393.     } 
  394.     {
  395.       outtoken ( logfile ) ; 
  396.     } 
  397.     {
  398.       (void) fprintf( logfile , "%s%ld\n",  " is an integer literal with value " ,           (long)tokenvalue ) ; 
  399.     } 
  400. #endif /* TRACE */
  401.     literalloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 1 
  402.     , true ) ; 
  403.     if ( ( ! hashfound ) ) 
  404.     {
  405.       fntype [ literalloc ] = 2 ; 
  406.       ilkinfo [ literalloc ] = tokenvalue ; 
  407.     } 
  408.     if ( ( ( lexclass [ buffer [ bufptr2 ] ] != 1 ) && ( bufptr2 < last ) 
  409.     && ( buffer [ bufptr2 ] != 125 ) && ( buffer [ bufptr2 ] != 37 ) ) ) 
  410.     {
  411.       skipillegalstuffafte () ; 
  412.       goto lab25 ; 
  413.     } 
  414.     {
  415.       singlfunction [ singleptr ] = literalloc ; 
  416.       if ( ( singleptr == singlefnspace ) ) 
  417.       singlfnoverflow () ; 
  418.       incr ( singleptr ) ; 
  419.     } 
  420.       } 
  421.       break ; 
  422.     case 34 : 
  423.       {
  424.     incr ( bufptr2 ) ; 
  425.     if ( ( ! scan1 ( 34 ) ) ) 
  426.     {
  427.       {
  428.         (void) fprintf( logfile , "%s%c%s",  "No `" , xchr [ 34 ] , "' to end string literal"             ) ; 
  429.         (void) fprintf( stdout , "%s%c%s",  "No `" , xchr [ 34 ] , "' to end string literal"             ) ; 
  430.       } 
  431.       skiptokenprint () ; 
  432.       goto lab25 ; 
  433.     } 
  434.     ;
  435. #ifdef TRACE
  436.     {
  437.       (void) putc( '"' ,  logfile );
  438.     } 
  439.     {
  440.       outtoken ( logfile ) ; 
  441.     } 
  442.     {
  443.       (void) putc( '"' ,  logfile );
  444.     } 
  445.     {
  446.       (void) fprintf( logfile , "%s\n",  " is a string literal" ) ; 
  447.     } 
  448. #endif /* TRACE */
  449.     literalloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 0 
  450.     , true ) ; 
  451.     fntype [ literalloc ] = 3 ; 
  452.     incr ( bufptr2 ) ; 
  453.     if ( ( ( lexclass [ buffer [ bufptr2 ] ] != 1 ) && ( bufptr2 < last ) 
  454.     && ( buffer [ bufptr2 ] != 125 ) && ( buffer [ bufptr2 ] != 37 ) ) ) 
  455.     {
  456.       skipillegalstuffafte () ; 
  457.       goto lab25 ; 
  458.     } 
  459.     {
  460.       singlfunction [ singleptr ] = literalloc ; 
  461.       if ( ( singleptr == singlefnspace ) ) 
  462.       singlfnoverflow () ; 
  463.       incr ( singleptr ) ; 
  464.     } 
  465.       } 
  466.       break ; 
  467.     case 39 : 
  468.       {
  469.     incr ( bufptr2 ) ; 
  470.     if ( ( scan2white ( 125 , 37 ) ) ) 
  471.     ; 
  472.     ;
  473. #ifdef TRACE
  474.     {
  475.       (void) putc( '\'' ,  logfile );
  476.     } 
  477.     {
  478.       outtoken ( logfile ) ; 
  479.     } 
  480.     {
  481.       (void) Fputs( logfile ,  " is a quoted function " ) ; 
  482.     } 
  483. #endif /* TRACE */
  484.     lowercase ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) ) ; 
  485.     fnloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 11 , 
  486.     false ) ; 
  487.     if ( ( ! hashfound ) ) 
  488.     {
  489.       skptokenunknownfunct () ; 
  490.       goto lab25 ; 
  491.     } 
  492.     else {
  493.         
  494.       if ( ( fnloc == wizloc ) ) 
  495.       {
  496.         printrecursionillega () ; 
  497.         goto lab25 ; 
  498.       } 
  499.       else {
  500.           
  501.     ;
  502. #ifdef TRACE
  503.         {
  504.           (void) Fputs( logfile ,  "of type " ) ; 
  505.         } 
  506.         traceprfnclass ( fnloc ) ; 
  507.         {
  508.           (void) putc('\n',  logfile );
  509.         } 
  510. #endif /* TRACE */
  511.         {
  512.           singlfunction [ singleptr ] = 0 ; 
  513.           if ( ( singleptr == singlefnspace ) ) 
  514.           singlfnoverflow () ; 
  515.           incr ( singleptr ) ; 
  516.         } 
  517.         {
  518.           singlfunction [ singleptr ] = fnloc ; 
  519.           if ( ( singleptr == singlefnspace ) ) 
  520.           singlfnoverflow () ; 
  521.           incr ( singleptr ) ; 
  522.         } 
  523.       } 
  524.     } 
  525.       } 
  526.       break ; 
  527.     case 123 : 
  528.       {
  529.     exbuf [ 0 ] = 39 ; 
  530.     inttoASCII ( implfnnum , exbuf , 1 , endofnum ) ; 
  531.     implfnloc = strlookup ( exbuf , 0 , endofnum , 11 , true ) ; 
  532.     if ( ( hashfound ) ) 
  533.     {
  534.       {
  535.         (void) Fputs( logfile ,  "Already encountered implicit function" ) ; 
  536.         (void) Fputs( stdout ,  "Already encountered implicit function" ) ; 
  537.       } 
  538.       printconfusion () ; 
  539.       longjmp(jmp9998,1) ; 
  540.     } 
  541.     ;
  542. #ifdef TRACE
  543.     {
  544.       outpoolstr ( logfile , hashtext [ implfnloc ] ) ; 
  545.     } 
  546.     {
  547.       (void) fprintf( logfile , "%s\n",  " is an implicit function" ) ; 
  548.     } 
  549. #endif /* TRACE */
  550.     incr ( implfnnum ) ; 
  551.     fntype [ implfnloc ] = 1 ; 
  552.     {
  553.       singlfunction [ singleptr ] = 0 ; 
  554.       if ( ( singleptr == singlefnspace ) ) 
  555.       singlfnoverflow () ; 
  556.       incr ( singleptr ) ; 
  557.     } 
  558.     {
  559.       singlfunction [ singleptr ] = implfnloc ; 
  560.       if ( ( singleptr == singlefnspace ) ) 
  561.       singlfnoverflow () ; 
  562.       incr ( singleptr ) ; 
  563.     } 
  564.     incr ( bufptr2 ) ; 
  565.     scanfndef ( implfnloc ) ; 
  566.       } 
  567.       break ; 
  568.       default: 
  569.       {
  570.     if ( ( scan2white ( 125 , 37 ) ) ) 
  571.     ; 
  572.     ;
  573. #ifdef TRACE
  574.     {
  575.       outtoken ( logfile ) ; 
  576.     } 
  577.     {
  578.       (void) Fputs( logfile ,  " is a function " ) ; 
  579.     } 
  580. #endif /* TRACE */
  581.     lowercase ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) ) ; 
  582.     fnloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 11 , 
  583.     false ) ; 
  584.     if ( ( ! hashfound ) ) 
  585.     {
  586.       skptokenunknownfunct () ; 
  587.       goto lab25 ; 
  588.     } 
  589.     else if ( ( fnloc == wizloc ) ) 
  590.     {
  591.       printrecursionillega () ; 
  592.       goto lab25 ; 
  593.     } 
  594.     else {
  595.         
  596.     ;
  597. #ifdef TRACE
  598.       {
  599.         (void) Fputs( logfile ,  "of type " ) ; 
  600.       } 
  601.       traceprfnclass ( fnloc ) ; 
  602.       {
  603.         (void) putc('\n',  logfile );
  604.       } 
  605. #endif /* TRACE */
  606.       {
  607.         singlfunction [ singleptr ] = fnloc ; 
  608.         if ( ( singleptr == singlefnspace ) ) 
  609.         singlfnoverflow () ; 
  610.         incr ( singleptr ) ; 
  611.       } 
  612.     } 
  613.       } 
  614.       break ; 
  615.     } 
  616.     lab25: {
  617.     
  618.       if ( ( ! eatbstwhitespace () ) ) 
  619.       {
  620.     eatbstprint () ; 
  621.     {
  622.       {
  623.         (void) Fputs( logfile ,  "function" ) ; 
  624.         (void) Fputs( stdout ,  "function" ) ; 
  625.       } 
  626.       {
  627.         bsterrprintandlookfo () ; 
  628.         goto lab10 ; 
  629.       } 
  630.     } 
  631.       } 
  632.     } 
  633.   } 
  634.   {
  635.     {
  636.       singlfunction [ singleptr ] = 5001 ; 
  637.       if ( ( singleptr == singlefnspace ) ) 
  638.       singlfnoverflow () ; 
  639.       incr ( singleptr ) ; 
  640.     } 
  641.     if ( ( singleptr + wizdefptr > wizfnspace ) ) 
  642.     {
  643.       {
  644.     (void) fprintf( logfile , "%ld%s",  (long)singleptr + wizdefptr , ": " ) ; 
  645.     (void) fprintf( stdout , "%ld%s",  (long)singleptr + wizdefptr , ": " ) ; 
  646.       } 
  647.       {
  648.     printoverflow () ; 
  649.     {
  650.       (void) fprintf( logfile , "%s%ld\n",  "wizard-defined function space " , (long)wizfnspace ) 
  651.       ; 
  652.       (void) fprintf( stdout , "%s%ld\n",  "wizard-defined function space " , (long)wizfnspace ) ; 
  653.     } 
  654.     longjmp(jmp9998,1) ; 
  655.       } 
  656.     } 
  657.     ilkinfo [ fnhashloc ] = wizdefptr ; 
  658.     copyptr = 0 ; 
  659.     while ( ( copyptr < singleptr ) ) {
  660.     
  661.       wizfunctions [ wizdefptr ] = singlfunction [ copyptr ] ; 
  662.       incr ( copyptr ) ; 
  663.       incr ( wizdefptr ) ; 
  664.     } 
  665.   } 
  666.   incr ( bufptr2 ) ; 
  667.   lab10: ; 
  668. } 
  669. boolean eatbibwhitespace () {
  670.     /* 10 */ register boolean Result; while ( ( ! 
  671.   scanwhitespace () ) ) {
  672.       
  673.     if ( ( ! inputln ( bibfile [ bibptr ] ) ) ) 
  674.     {
  675.       Result = false ; 
  676.       goto lab10 ; 
  677.     } 
  678.     incr ( biblinenum ) ; 
  679.     bufptr2 = 0 ; 
  680.   } 
  681.   Result = true ; 
  682.   lab10: ; 
  683.   return(Result) ; 
  684. } 
  685. boolean compressbibwhite () {
  686.     /* 10 */ register boolean Result; Result = false 
  687.   ; 
  688.   {
  689.     if ( ( exbufptr == bufsize ) ) 
  690.     {
  691.       bibfieldtoolongprint () ; 
  692.       goto lab10 ; 
  693.     } 
  694.     else {
  695.     
  696.       exbuf [ exbufptr ] = 32 ; 
  697.       incr ( exbufptr ) ; 
  698.     } 
  699.   } 
  700.   while ( ( ! scanwhitespace () ) ) {
  701.       
  702.     if ( ( ! inputln ( bibfile [ bibptr ] ) ) ) 
  703.     {
  704.       eatbibprint () ; 
  705.       goto lab10 ; 
  706.     } 
  707.     incr ( biblinenum ) ; 
  708.     bufptr2 = 0 ; 
  709.   } 
  710.   Result = true ; 
  711.   lab10: ; 
  712.   return(Result) ; 
  713. } 
  714. boolean scanbalancedbraces () {
  715.     /* 15 10 */ register boolean Result; Result = 
  716.   false ; 
  717.   incr ( bufptr2 ) ; 
  718.   {
  719.     if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 == last ) ) ) 
  720.     if ( ( ! compressbibwhite () ) ) 
  721.     goto lab10 ; 
  722.   } 
  723.   if ( ( exbufptr > 1 ) ) 
  724.   if ( ( exbuf [ exbufptr - 1 ] == 32 ) ) 
  725.   if ( ( exbuf [ exbufptr - 2 ] == 32 ) ) 
  726.   decr ( exbufptr ) ; 
  727.   bibbracelevel = 0 ; 
  728.   if ( ( storefield ) ) 
  729.   {
  730.     while ( ( buffer [ bufptr2 ] != rightstrdelim ) ) switch ( ( buffer [ 
  731.     bufptr2 ] ) ) 
  732.     {case 123 : 
  733.       {
  734.     incr ( bibbracelevel ) ; 
  735.     {
  736.       if ( ( exbufptr == bufsize ) ) 
  737.       {
  738.         bibfieldtoolongprint () ; 
  739.         goto lab10 ; 
  740.       } 
  741.       else {
  742.           
  743.         exbuf [ exbufptr ] = 123 ; 
  744.         incr ( exbufptr ) ; 
  745.       } 
  746.     } 
  747.     incr ( bufptr2 ) ; 
  748.     {
  749.       if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 == last 
  750.       ) ) ) 
  751.       if ( ( ! compressbibwhite () ) ) 
  752.       goto lab10 ; 
  753.     } 
  754.     {
  755.       while ( true ) switch ( ( buffer [ bufptr2 ] ) ) 
  756.       {case 125 : 
  757.         {
  758.           decr ( bibbracelevel ) ; 
  759.           {
  760.         if ( ( exbufptr == bufsize ) ) 
  761.         {
  762.           bibfieldtoolongprint () ; 
  763.           goto lab10 ; 
  764.         } 
  765.         else {
  766.             
  767.           exbuf [ exbufptr ] = 125 ; 
  768.           incr ( exbufptr ) ; 
  769.         } 
  770.           } 
  771.           incr ( bufptr2 ) ; 
  772.           {
  773.         if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 
  774.         == last ) ) ) 
  775.         if ( ( ! compressbibwhite () ) ) 
  776.         goto lab10 ; 
  777.           } 
  778.           if ( ( bibbracelevel == 0 ) ) 
  779.           goto lab15 ; 
  780.         } 
  781.         break ; 
  782.       case 123 : 
  783.         {
  784.           incr ( bibbracelevel ) ; 
  785.           {
  786.         if ( ( exbufptr == bufsize ) ) 
  787.         {
  788.           bibfieldtoolongprint () ; 
  789.           goto lab10 ; 
  790.         } 
  791.         else {
  792.             
  793.           exbuf [ exbufptr ] = 123 ; 
  794.           incr ( exbufptr ) ; 
  795.         } 
  796.           } 
  797.           incr ( bufptr2 ) ; 
  798.           {
  799.         if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 
  800.         == last ) ) ) 
  801.         if ( ( ! compressbibwhite () ) ) 
  802.         goto lab10 ; 
  803.           } 
  804.         } 
  805.         break ; 
  806.         default: 
  807.         {
  808.           {
  809.         if ( ( exbufptr == bufsize ) ) 
  810.         {
  811.           bibfieldtoolongprint () ; 
  812.           goto lab10 ; 
  813.         } 
  814.         else {
  815.             
  816.           exbuf [ exbufptr ] = buffer [ bufptr2 ] ; 
  817.           incr ( exbufptr ) ; 
  818.         } 
  819.           } 
  820.           incr ( bufptr2 ) ; 
  821.           {
  822.         if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 
  823.         == last ) ) ) 
  824.         if ( ( ! compressbibwhite () ) ) 
  825.         goto lab10 ; 
  826.           } 
  827.         } 
  828.         break ; 
  829.       } 
  830.       lab15: ; 
  831.     } 
  832.       } 
  833.       break ; 
  834.     case 125 : 
  835.       {
  836.     bibunbalancedbracesp () ; 
  837.     goto lab10 ; 
  838.       } 
  839.       break ; 
  840.       default: 
  841.       {
  842.     {
  843.       if ( ( exbufptr == bufsize ) ) 
  844.       {
  845.         bibfieldtoolongprint () ; 
  846.         goto lab10 ; 
  847.       } 
  848.       else {
  849.           
  850.         exbuf [ exbufptr ] = buffer [ bufptr2 ] ; 
  851.         incr ( exbufptr ) ; 
  852.       } 
  853.     } 
  854.     incr ( bufptr2 ) ; 
  855.     {
  856.       if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 == last 
  857.       ) ) ) 
  858.       if ( ( ! compressbibwhite () ) ) 
  859.       goto lab10 ; 
  860.     } 
  861.       } 
  862.       break ; 
  863.     } 
  864.   } 
  865.   else {
  866.       
  867.     while ( ( buffer [ bufptr2 ] != rightstrdelim ) ) if ( ( buffer [ bufptr2 
  868.     ] == 123 ) ) 
  869.     {
  870.       incr ( bibbracelevel ) ; 
  871.       incr ( bufptr2 ) ; 
  872.       {
  873.     if ( ( ! eatbibwhitespace () ) ) 
  874.     {
  875.       eatbibprint () ; 
  876.       goto lab10 ; 
  877.     } 
  878.       } 
  879.       while ( ( bibbracelevel > 0 ) ) {
  880.       
  881.     if ( ( buffer [ bufptr2 ] == 125 ) ) 
  882.     {
  883.       decr ( bibbracelevel ) ; 
  884.       incr ( bufptr2 ) ; 
  885.       {
  886.         if ( ( ! eatbibwhitespace () ) ) 
  887.         {
  888.           eatbibprint () ; 
  889.           goto lab10 ; 
  890.         } 
  891.       } 
  892.     } 
  893.     else if ( ( buffer [ bufptr2 ] == 123 ) ) 
  894.     {
  895.       incr ( bibbracelevel ) ; 
  896.       incr ( bufptr2 ) ; 
  897.       {
  898.         if ( ( ! eatbibwhitespace () ) ) 
  899.         {
  900.           eatbibprint () ; 
  901.           goto lab10 ; 
  902.         } 
  903.       } 
  904.     } 
  905.     else {
  906.         
  907.       incr ( bufptr2 ) ; 
  908.       if ( ( ! scan2 ( 125 , 123 ) ) ) 
  909.       {
  910.         if ( ( ! eatbibwhitespace () ) ) 
  911.         {
  912.           eatbibprint () ; 
  913.           goto lab10 ; 
  914.         } 
  915.       } 
  916.     } 
  917.       } 
  918.     } 
  919.     else if ( ( buffer [ bufptr2 ] == 125 ) ) 
  920.     {
  921.       bibunbalancedbracesp () ; 
  922.       goto lab10 ; 
  923.     } 
  924.     else {
  925.     
  926.       incr ( bufptr2 ) ; 
  927.       if ( ( ! scan3 ( rightstrdelim , 123 , 125 ) ) ) 
  928.       {
  929.     if ( ( ! eatbibwhitespace () ) ) 
  930.     {
  931.       eatbibprint () ; 
  932.       goto lab10 ; 
  933.     } 
  934.       } 
  935.     } 
  936.   } 
  937.   incr ( bufptr2 ) ; 
  938.   Result = true ; 
  939.   lab10: ; 
  940.   return(Result) ; 
  941. } 
  942. boolean scanafieldtokenandea () {
  943.     /* 10 */ register boolean Result; Result = 
  944.   false ; 
  945.   switch ( ( buffer [ bufptr2 ] ) ) 
  946.   {case 123 : 
  947.     {
  948.       rightstrdelim = 125 ; 
  949.       if ( ( ! scanbalancedbraces () ) ) 
  950.       goto lab10 ; 
  951.     } 
  952.     break ; 
  953.   case 34 : 
  954.     {
  955.       rightstrdelim = 34 ; 
  956.       if ( ( ! scanbalancedbraces () ) ) 
  957.       goto lab10 ; 
  958.     } 
  959.     break ; 
  960.   case 48 : 
  961.   case 49 : 
  962.   case 50 : 
  963.   case 51 : 
  964.   case 52 : 
  965.   case 53 : 
  966.   case 54 : 
  967.   case 55 : 
  968.   case 56 : 
  969.   case 57 : 
  970.     {
  971.       if ( ( ! scannonneginteger () ) ) 
  972.       {
  973.     {
  974.       (void) Fputs( logfile ,  "A digit disappeared" ) ; 
  975.       (void) Fputs( stdout ,  "A digit disappeared" ) ; 
  976.     } 
  977.     printconfusion () ; 
  978.     longjmp(jmp9998,1) ; 
  979.       } 
  980.       if ( ( storefield ) ) 
  981.       {
  982.     tmpptr = bufptr1 ; 
  983.     while ( ( tmpptr < bufptr2 ) ) {
  984.         
  985.       {
  986.         if ( ( exbufptr == bufsize ) ) 
  987.         {
  988.           bibfieldtoolongprint () ; 
  989.           goto lab10 ; 
  990.         } 
  991.         else {
  992.         
  993.           exbuf [ exbufptr ] = buffer [ tmpptr ] ; 
  994.           incr ( exbufptr ) ; 
  995.         } 
  996.       } 
  997.       incr ( tmpptr ) ; 
  998.     } 
  999.       } 
  1000.     } 
  1001.     break ; 
  1002.     default: 
  1003.     {
  1004.       scanidentifier ( 44 , rightouterdelim , 35 ) ; 
  1005.       {
  1006.     if ( ( ( scanresult == 3 ) || ( scanresult == 1 ) ) ) 
  1007.     ; 
  1008.     else {
  1009.         
  1010.       bibidprint () ; 
  1011.       {
  1012.         {
  1013.           (void) Fputs( logfile ,  "a field part" ) ; 
  1014.           (void) Fputs( stdout ,  "a field part" ) ; 
  1015.         } 
  1016.         biberrprint () ; 
  1017.         goto lab10 ; 
  1018.       } 
  1019.     } 
  1020.       } 
  1021.       if ( ( storefield ) ) 
  1022.       {
  1023.     lowercase ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) ) ; 
  1024.     macronameloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 
  1025.     13 , false ) ; 
  1026.     storetoken = true ; 
  1027.     if ( ( atbibcommand ) ) 
  1028.     if ( ( commandnum == 2 ) ) 
  1029.     if ( ( macronameloc == curmacroloc ) ) 
  1030.     {
  1031.       storetoken = false ; 
  1032.       {
  1033.         macrowarnprint () ; 
  1034.         {
  1035.           {
  1036.         (void) fprintf( logfile , "%s\n",  "used in its own definition" ) ; 
  1037.         (void) fprintf( stdout , "%s\n",  "used in its own definition" ) ; 
  1038.           } 
  1039.           bibwarnprint () ; 
  1040.         } 
  1041.       } 
  1042.     } 
  1043.     if ( ( ! hashfound ) ) 
  1044.     {
  1045.       storetoken = false ; 
  1046.       {
  1047.         macrowarnprint () ; 
  1048.         {
  1049.           {
  1050.         (void) fprintf( logfile , "%s\n",  "undefined" ) ; 
  1051.         (void) fprintf( stdout , "%s\n",  "undefined" ) ; 
  1052.           } 
  1053.           bibwarnprint () ; 
  1054.         } 
  1055.       } 
  1056.     } 
  1057.     if ( ( storetoken ) ) 
  1058.     {
  1059.       tmpptr = strstart [ ilkinfo [ macronameloc ] ] ; 
  1060.       tmpendptr = strstart [ ilkinfo [ macronameloc ] + 1 ] ; 
  1061.       if ( ( exbufptr == 0 ) ) 
  1062.       if ( ( ( lexclass [ strpool [ tmpptr ] ] == 1 ) && ( tmpptr < 
  1063.       tmpendptr ) ) ) 
  1064.       {
  1065.         {
  1066.           if ( ( exbufptr == bufsize ) ) 
  1067.           {
  1068.         bibfieldtoolongprint () ; 
  1069.         goto lab10 ; 
  1070.           } 
  1071.           else {
  1072.           
  1073.         exbuf [ exbufptr ] = 32 ; 
  1074.         incr ( exbufptr ) ; 
  1075.           } 
  1076.         } 
  1077.         incr ( tmpptr ) ; 
  1078.         while ( ( ( lexclass [ strpool [ tmpptr ] ] == 1 ) && ( tmpptr < 
  1079.         tmpendptr ) ) ) incr ( tmpptr ) ; 
  1080.       } 
  1081.       while ( ( tmpptr < tmpendptr ) ) {
  1082.           
  1083.         if ( ( lexclass [ strpool [ tmpptr ] ] != 1 ) ) 
  1084.         {
  1085.           if ( ( exbufptr == bufsize ) ) 
  1086.           {
  1087.         bibfieldtoolongprint () ; 
  1088.         goto lab10 ; 
  1089.           } 
  1090.           else {
  1091.           
  1092.         exbuf [ exbufptr ] = strpool [ tmpptr ] ; 
  1093.         incr ( exbufptr ) ; 
  1094.           } 
  1095.         } 
  1096.         else if ( ( exbuf [ exbufptr - 1 ] != 32 ) ) 
  1097.         {
  1098.           if ( ( exbufptr == bufsize ) ) 
  1099.           {
  1100.         bibfieldtoolongprint () ; 
  1101.         goto lab10 ; 
  1102.           } 
  1103.           else {
  1104.           
  1105.         exbuf [ exbufptr ] = 32 ; 
  1106.         incr ( exbufptr ) ; 
  1107.           } 
  1108.         } 
  1109.         incr ( tmpptr ) ; 
  1110.       } 
  1111.     } 
  1112.       } 
  1113.     } 
  1114.     break ; 
  1115.   } 
  1116.   {
  1117.     if ( ( ! eatbibwhitespace () ) ) 
  1118.     {
  1119.       eatbibprint () ; 
  1120.       goto lab10 ; 
  1121.     } 
  1122.   } 
  1123.   Result = true ; 
  1124.   lab10: ; 
  1125.   return(Result) ; 
  1126. } 
  1127.